{ "cells": [ { "cell_type": "markdown", "id": "continuous-certificate", "metadata": {}, "source": [ "
\n", " Datavisualisation\n", "
\n", "

Navigation dans la page

\n", "

\n", " Si c'est votre première visite dans ce TP, lisez attentivement chacun des points détaillé après ce paragraphe.
\n", " Si vous avez déjà commencer à travailler sur ce TP et que vous souhaiter vous déplacer rapidement dans une partie précise vous pouvez choisir la partie que vous souhaitez rejoindre ci-dessous. N'oubliez pas de réexecuter les case contenant des bibliothèques nécessaire au reste du code.
\n", "

\n", " Menu de navigation\n", " \n", "
\n", "

\n", "\n", "
\n", " Technologie jupyter\n", "

\n", " La technologie jupyter permet d'exécuter du code python par un simple clique sur Executer ci-dessus.
\n", " Les morceaux de code de cette page sont interprétées case par case. Pour savoir quelle case a été interprétée avant une autre, il suffit de repérer le numéro devant la case.
\n", " Une fois qu'une case a été interprétée (=exécutée), la page garde en mémoire les variables et fonctions lues
\n", " La plateforme propose quelques outils de purge de la mémoire : \n", "

\n", "

\n", "
\n", "

SAUVEGARDER VOTRE TRAVAIL

\n", "

\n", " Pour ne pas perdre votre travail pensez à le sauvegarder régulièrement. Par défault, la sauvegarde par un clic sur la disquette en haut à gauche de page, ou par le racourci clavier classique ctrl+S\n", " est une sauvegarde en local, sur le serveur de jupyter. Vous pouvez et devez très régulièrement sauvegarder votre travail sur votre support personnel de sauvegarde (clef USB, se l'envoyer par mail etc). Ce faisant vous disposerez d'un fichier .ipynb (IPYthon NoteBook) qu'il vous suffira de recharger pour avancer. Après le rechargement assurez vous que les fonctionnalités anciennement developpées et variables utilisées sont bien dans la mémoire de la page (en rééxecutant les cases, ou plus rapidement par Kernel > Restart & Run All.

\n", "

A NOTER : vous pouvez travailler sur le tp (et tout autre fichier .ipynb) hors connexion en installant une version local du notebook de jupyter. Il faut que votre machine possède un interpreteur de python et que vous soyez connecter à internet.\n", "

    \n", "
  1. Lancer un terminal
    2. \n", "
  2. Taper la commande suivante : pip install jupyterlab
    3. \n", "
  3. Une fois l'installation terminée portez votre attention sur les dernières lignes affichées dans votre terminal vous invitant probablement à taper une ligne de commande pour faire une mise à jour
    4. \n", "
  4. Pour lancer notebook de jupyter, taper dans votre termial : jupyter notebook
    5. \n", "
  5. Votre simulateur de serveur est lancé. Il ne faut pas fermer votre terminal, auquel cas votre simulateur de serveur s'interompera. Suivez le lien indiqué dans les dernières lignes de votre terminal pour vous diriger vers votre espace local. L'interface se présente comme celle que vous trouverez sur le web. Votre travail sera cependant toujours enregistré et jamais perdu même si vous le consultez après plusieurs jours
    6. \n", "
\n", "

\n", "
\n", "
" ] }, { "cell_type": "markdown", "id": "pressed-burden", "metadata": {}, "source": [ "
\n", " Retour sur les listes\n", "
\n", "

\n", "

\n", " Menu de navigation\n", " \n", "
\n", "

" ] }, { "cell_type": "markdown", "id": "proper-bradley", "metadata": {}, "source": [ "

Pour pouvoir réaliser des graphiques en python, nous avons besoin de spécifier des listes (de points). La fonction de base est la fonction range qui permet très rapidement d'énumeré des entiers (et non des nombres décimaux). Voici les trois utilisations possibles : \n", "

    \n", "
  1. range(n) qui donne la liste des entiers de 0 à n-1. Par exemple range(10) donnera [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    2. \n", "
  2. range(a, b) qui donne la liste des entiers entre a et b-1. Par exemple range(3, 10) donnera [3, 4, 5, 6, 7, 8, 9]
    3. \n", "
  3. range(a, b, p) qui donne la liste des entiers entre a et b-1 par bond de p. Par exemple range(3, 10, 3) donnera [3, 6, 9]
    4. \n", "
\n", "\n", "En plus d'être une fonction range est un type en python. Pour s'en convaincre utilisons la fonction type qui renvoie le type d'une variable en python.\n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "reflected-sample", "metadata": {}, "outputs": [], "source": [ "#Le type 'int' pour les entiers\n", "x=10\n", "print(\"type de '10' :\", type(x))\n", "\n", "#Le type 'float' pour les réels\n", "x=1.0\n", "print(\"type de '1.0' :\", type(x))\n", "\n", "#Le type 'list' pour les listes\n", "x=[10]\n", "print(\"type de '[10]' :\", type(x))\n", "\n", "#Le type 'range' pour les listes organisées\n", "x=range(10)\n", "print(\"type de 'range(10)' :\", type(x))" ] }, { "cell_type": "markdown", "id": "nuclear-affairs", "metadata": {}, "source": [ "

Pour passer d'un type à l'autre on réalise un cast. Pour cela on utilise les fonctions qui portent le nom des types.

" ] }, { "cell_type": "code", "execution_count": null, "id": "35105b30", "metadata": {}, "outputs": [], "source": [ "x=10\n", "print(\"x =\", x)\n", "print(\"type de 'x' :\", type(x))\n", "print(\"type de 'float(x)' :\", type(float(x)))\n", "\n", "x=1.0\n", "print(\"x =\", x)\n", "print(\"type de 'x' :\", type(x))\n", "print(\"type de 'int(x)' :\", type(int(x)))" ] }, { "cell_type": "markdown", "id": "11195a75", "metadata": {}, "source": [ "

Exercice

\n", "

Afficher la liste des entiers impaires entre $123$ et $456$

" ] }, { "cell_type": "code", "execution_count": null, "id": "38f5f7c1", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "general-equipment", "metadata": {}, "source": [ "

Il est possible de créer des listes de nombres pas forcément entiers de la manière suivante : \n", "

\n", " y=[fonction de x for x in valeur]\n", "
\n", "Dans ce cas la liste y aura dans chacune de ses cases la valeur de f(x) pour les différentes valeurs prises par x. Par exemples si\n", "\n", "
\n", " y=y=[5*x-5 for x in range(-9, 10, 2)]\n", "
\n", "alors \n", "y=[-50, -40, -30, -20, -10, 0, 10, 20, 30, 40]\n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "swedish-elite", "metadata": {}, "outputs": [], "source": [ "y=[5*x-5 for x in range(-9, 10, 2)]\n", "print(y)" ] }, { "cell_type": "markdown", "id": "muslim-drawing", "metadata": {}, "source": [ "

\n", "Il est également possible de spécifier une condition à l'aide de if. Par exemple\n", "

\n", " y=[5*x-5 for x in range(-9, 10, 2) if(5*x-5!=0)]\n", "
\n", "affichera la même liste que précédement sauf $0$\n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "found-float", "metadata": {}, "outputs": [], "source": [ "y=[5*x-5 for x in range(-9, 10, 2) if(5*x-5!=0)]\n", "print(y)" ] }, { "cell_type": "markdown", "id": "resident-possession", "metadata": {}, "source": [ "

Exercice

\n", "

Afficher la liste des entiers impaires entre $123$ et $456$ qui sont multiple de $3$

" ] }, { "cell_type": "code", "execution_count": null, "id": "random-elizabeth", "metadata": {}, "outputs": [], "source": [ "\n", "#Réponse : [123, 129, 135, 141, 147, 153, 159, 165, 171, 177, 183, 189, 195, 201, 207, 213, 219, 225, 231, 237, 243, 249, 255, 261, 267, 273, 279, 285, 291, 297, 303, 309, 315, 321, 327, 333, 339, 345, 351, 357, 363, 369, 375, 381, 387, 393, 399, 405, 411, 417, 423, 429, 435, 441, 447, 453]" ] }, { "cell_type": "markdown", "id": "stuck-nation", "metadata": {}, "source": [ "
\n", " La bibliothèque math\n", "
\n", "

\n", "

\n", " Menu de navigation\n", " \n", "
\n", "

" ] }, { "cell_type": "markdown", "id": "funny-publicity", "metadata": {}, "source": [ "

Comme n'importe quelle calculatrice, nous souhaitons pouvoir utiliser des fonctions comme le cosinus, la racine carrée, le logarithme etc. Pour pouvoir utiliser ces fonctionnalités dites avancées il faut les charger dans le programme. Autrement dit : pour calculer la racine carrée de $2$, il faut écrire un programme de calcul de la racine carrée. Fort heureusement d'autres s'en sont déjà occupé ! Le fait de charger cette fonction revient à aller chercher le code d'autre programmeur et de simplement l'utiliser. Toutes les fonctions mathématiques dont nous pourrions avoir besoin sont rangées dans une bibliothèque : math (original).

\n", "\n", "

\n", "Voici le fonctions que nous pouvons y trouver.\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
MathématiquesPython
$|x|$abs(x)
$\\sqrt{x}$sqrt(x)
$e^x$exp(x)
$ln(x)$log(x)
$log(x)$log10(x)
$cos(x)$cos(x)
$sin(x)$sin(x)
$tan(x)$tan(x)
$\\pi$pi
$e(=e^1)$e
$x^y$pow(x, y)
$n!$factorial(n)
\n", "\n", "Il existe plusieurs maniènes de charger ces fonctions :\n", "

    \n", "
  1. Importer toute la bibliothèque\n", "
    \n", " import math\n", "
    \n", " qui s'utilise en appelant les fonctions précédées du nom de la bibliothèque x=math.cos(0)+math.exp(1).\n", "
    2. \n", "
  2. Importer des fonctions spécifiques en changeant leur nom (on parle d'allias) : pour cela il faut dire en python : \"importe depuis la bibliothèque XXX, les fonctions Y sous le nom y, Z sous le nom z, etc\" ce qui donne\n", "
    \n", " from math import cos as trigoDifficile, sin as trigoDifficile2, exp as UneFonctionDeTerminale\n", "
    \n", " et qui s'utilise comme d'habitude mais avec leur nouveau nom comme par exemple x=trigoDificille(0)+UneFonctionDeTerminale(1).\n", "
    3. \n", "
  3. Importer des fonctions spécifiques sans changer leur nom\n", "
    \n", " from math import cos, sin, exp\n", "
    \n", " et qui s'utilise comme d'habitude comme par exemple x=cos(0)+exp(1).\n", "
    4. \n", "
  4. \n", " Importer toutes les fonctions d'une bibliothèque\n", "
    \n", " from math import *\n", "
    \n", " et qui s'utilise comme dans le cas précédent.\n", "
    5. \n", "
\n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "square-short", "metadata": {}, "outputs": [], "source": [ "import math\n", "x=math.cos(0)+math.exp(1)\n", "print(x)" ] }, { "cell_type": "code", "execution_count": null, "id": "czech-craps", "metadata": {}, "outputs": [], "source": [ "from math import cos, sin, exp\n", "x=cos(0)+exp(1)\n", "print(x)" ] }, { "cell_type": "code", "execution_count": null, "id": "pharmaceutical-major", "metadata": {}, "outputs": [], "source": [ "from math import cos as trigoDifficile, sin as trigoDifficile2, exp as UneFonctionDeTerminale\n", "x=trigoDifficile(0)+UneFonctionDeTerminale(1)\n", "print(x)" ] }, { "cell_type": "code", "execution_count": null, "id": "responsible-yield", "metadata": {}, "outputs": [], "source": [ "from math import *\n", "x=cos(0)+exp(1)\n", "print(x)" ] }, { "cell_type": "markdown", "id": "extraordinary-noise", "metadata": {}, "source": [ "

Exercice

\n", "
    \n", "
  1. Donner une valeur approchée au dixième de $\\sqrt{2}$.
    2. \n", "
  2. Donner une valeur approchée au centième du nombre d'or $\\dfrac{1+\\sqrt{5}}{2}$.
    3. \n", "
  3. Donner une valeur approchée au dixième de $cos(6*6*6)$.
    4. \n", "
  4. Donner une valeur approchée au dixième de $sin(666)$.
    5. \n", "
  5. Donner une valeur approchée de $tan\\left(\\dfrac{\\pi}{2}\\right)$.
    6. \n", "
  6. Donner la valeur de $1983!$.
    7. \n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "48dea0da", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "molecular-nursing", "metadata": {}, "source": [ "

Application

\n", "

\n", "Si l'on souhaite afficher la liste des carrés des nombres réels entre $0$ et $1$ de $0.1$ en $0.1$ voici comment on peut procéder : \n", "

\n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "gothic-croatia", "metadata": {}, "outputs": [], "source": [ "print([(x/10)**2 for x in range(11)])" ] }, { "cell_type": "markdown", "id": "filled-microwave", "metadata": {}, "source": [ "

\n", " Autre exemple : on souhaite calculer le logarithme népérien (log) de $x^2+x-6$ pour $101$ valeurs équi-répartie dans l'intervalle $[-3 ; 3]$.\n", "

\n", " Au finale pour répondre à la question, on fait : \n", "\n", "
\n", " A=[-3+6*x/100 for x in range(101)]\n", "
\n", "
\n", " B=[x**2+x-6 for x in A if(x**2+x-6>0)]\n", "
\n", "
\n", " C=[log(x) for x in B]\n", "
\n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "5ad7b969", "metadata": {}, "outputs": [], "source": [ "A=[-3+6*x/100 for x in range(101)]\n", "B=[x**2+x-6 for x in A if(x**2+x-6>0)]\n", "C=[log(x) for x in B]\n", "print(C)" ] }, { "cell_type": "markdown", "id": "confirmed-arthritis", "metadata": {}, "source": [ "

On peut bien sur simplifier cette rédaction

" ] }, { "cell_type": "code", "execution_count": null, "id": "ranking-vaccine", "metadata": {}, "outputs": [], "source": [ "D=[log((-3+6*x/100)**2+(-3+6*x/100)-6) for x in range(101) if (((-3+6*x/100)**2+(-3+6*x/100)-6)>0)]\n", "print(D)" ] }, { "cell_type": "markdown", "id": "simple-soviet", "metadata": {}, "source": [ "

Exercice

\n", "
    \n", "
  1. Afficher la liste de $exp(-\\sqrt{x^2-1})$ pour $100$ valeurs équi-réparties sur $[-1 ; 2]$
    2. \n", "
  2. Afficher la liste de $exp(-\\sqrt{x^2-1})$ pour $1000$ valeurs équi-réparties sur $[-1 ; 2]$
    3. \n", "
  3. Afficher la liste de $exp(-\\sqrt{x^2-1})$ pour $1000$ valeurs équi-réparties sur $[-3 ; 2]$
    4. \n", "
  4. Afficher la liste de $exp(-\\sqrt{x^2-1})$ pour $n$ valeurs équi-réparties sur $[a ; b]$ pour des valeurs $n$, $a$, $b$ paramètrables
    5. \n", "
" ] }, { "cell_type": "code", "execution_count": null, "id": "32f03f82", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "surgical-membership", "metadata": {}, "source": [ "
\n", " Graphiques en python\n", "
\n", "

\n", "

\n", " Menu de navigation\n", " \n", "
\n", "

" ] }, { "cell_type": "markdown", "id": "governmental-continent", "metadata": {}, "source": [ "

Comme pour les fonctions, il faut définir la fenêtre de graphique. Par chance, d'autres s'en sont occupés. Chargeons cette fonctionnalité : exécuter la case suivante.

" ] }, { "cell_type": "code", "execution_count": null, "id": "foster-nirvana", "metadata": {}, "outputs": [], "source": [ "from matplotlib.pyplot import *" ] }, { "cell_type": "markdown", "id": "adverse-civilization", "metadata": {}, "source": [ "

Pour faire un graphique rien de plus simple ! On utilise la fonction plot qui prend au moins deux paramètres : \n", "

    \n", "
  1. Le premier est la liste des points d'abscisses
    2. \n", "
  2. La seconde est la liste des points d'ordonnées
    3. \n", "
\n", "Voici un exemple : \n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "afe742ec", "metadata": {}, "outputs": [], "source": [ "X=[k/10 for k in range(-3, 4)]\n", "Y=[x**2 for x in X]\n", "plot(X, Y)" ] }, { "cell_type": "markdown", "id": "attempted-reflection", "metadata": {}, "source": [ "

La fonction plot crée un objet fenêtre graphique il faut demander à afficher cette fenêtre (NB: jupyter est très gentil, lorsqu'on ne lui indique pas d'afficher le graphique, il le fait tout seul. Pour s'en convaincre, remarquer le Out dans la marge de gauche).
\n", "Pour afficher la fenêtre graphique, on utilise la fonction show\n", "

" ] }, { "cell_type": "code", "execution_count": null, "id": "injured-maximum", "metadata": {}, "outputs": [], "source": [ "X=[k/10 for k in range(-3, 4)]\n", "Y=[x**2 for x in X]\n", "plot(X, Y)\n", "show()" ] }, { "cell_type": "markdown", "id": "caroline-luxembourg", "metadata": {}, "source": [ "

Quelques fonctionnalités supplémentaires

\n", "\n", "\n", "

Voici un exemple qui résume tout.

" ] }, { "cell_type": "code", "execution_count": null, "id": "radical-composition", "metadata": {}, "outputs": [], "source": [ "#Coordonnes des points\n", "X=[x/10 for x in range(10+1)]\n", "Y=[sqrt(x) for x in X]\n", "Z=[x**2 for x in X]\n", "\n", "#Dessin\n", "plot(X, Y, 'cx-', linewidth=1.5, label=\"$x\\mapsto \\sqrt{x}$\")\n", "plot(X, Z, 'm^--', label=\"$x\\mapsto x^2$\")\n", "plot(X, X, 'r*:', label=\"$x\\mapsto x$\")\n", "\n", "#Dimension de la fenêtre\n", "xlim(0, 1)\n", "ylim(0, 1)\n", "\n", "#Titre et légende\n", "title(\"Comparaison entre $x^2$ et $\\sqrt{x}$ sur $[0; 1]$\")\n", "xlabel(\"Abscisses\")\n", "ylabel(\"Ordonnées\")\n", "legend()\n", "\n", "#Quadrillage\n", "grid(True)\n", "\n", "#Affichage\n", "show()" ] }, { "cell_type": "markdown", "id": "international-paris", "metadata": {}, "source": [ "

Les possibilités sont très nombreuses. Pour explorer les possibilités de graphique en python à l'aide de matplotlib, on pourra consulter la documentation ici : https://matplotlib.org/.

\n", "\n", "

Voici quelques exemples.

" ] }, { "cell_type": "markdown", "id": "working-ethiopia", "metadata": {}, "source": [ "

Le nuage de point

\n", " \n", "

Pour réaliser un nuage de point on utilise la fonction scatter.

" ] }, { "cell_type": "code", "execution_count": null, "id": "tough-joseph", "metadata": {}, "outputs": [], "source": [ "X=[1,2,3]\n", "Y=[-1,0,1]\n", "scatter(X, Y)\n", "show()" ] }, { "cell_type": "markdown", "id": "demographic-color", "metadata": {}, "source": [ "

On pourra en apprendre plus sur cette fonction ici

" ] }, { "cell_type": "markdown", "id": "dirty-agreement", "metadata": {}, "source": [ "

Les graphiques polaires

\n", "

La fonction plot utilise des données cartésinnes, c'est à dire des $x$ et $y$ classiques. il existe une autre manière de représenter les points du plan : les coodonnées polaires. Dans ce cas on précise la distance à l'origine et l'angle (en radian) formé avec l'axe des demi-abscisses positif. La fonction polar réalise alors un grpahique circulaire.

" ] }, { "cell_type": "code", "execution_count": null, "id": "tropical-yugoslavia", "metadata": {}, "outputs": [], "source": [ "T=[pi/6, pi/4, pi/3]\n", "R=[1, 2, 3]\n", "polar(T, R)\n", "show()" ] }, { "cell_type": "markdown", "id": "iraqi-square", "metadata": {}, "source": [ "

Le diagramme en batôn

\n", "

La fonction bar permet de réaliser des diagrammes en batôn.

" ] }, { "cell_type": "code", "execution_count": null, "id": "hydraulic-cosmetic", "metadata": {}, "outputs": [], "source": [ "X=[1, 2, 10]\n", "H=[50, 20, 75]\n", "bar(X, H)\n", "show()" ] }, { "cell_type": "code", "execution_count": null, "id": "hawaiian-matrix", "metadata": {}, "outputs": [], "source": [ "X=[1, 2, 10]\n", "H=[50, 20, 75]\n", "bar(X, H, width=0.1)\n", "show()" ] }, { "cell_type": "code", "execution_count": null, "id": "ranking-experiment", "metadata": {}, "outputs": [], "source": [ "X=[1, 2, 10]\n", "H=[50, 20, 75]\n", "bar(X, H, width=0.1)\n", "xticks(X, ['Jeune', 'Adulte', 'Vieux'], rotation=-45)\n", "for i in range(len(X)) : text(X[i], H[i], str(H[i])+'%')\n", "title(\"Répartition\")\n", "show()" ] }, { "cell_type": "markdown", "id": "regional-italy", "metadata": {}, "source": [ "

On pourra en apprendre plus sur la fonction bar par ici

" ] }, { "cell_type": "markdown", "id": "designed-burton", "metadata": {}, "source": [ "

Dimensionnement de la figure

\n", "

Pour dimensionner une figure, il suffit d'utiliser figure(figsize=(hauteur, largeur)).

" ] }, { "cell_type": "code", "execution_count": null, "id": "exact-tuning", "metadata": {}, "outputs": [], "source": [ "figure(figsize=(2, 5))\n", "\n", "X=[1, 2, 10]\n", "H=[50, 20, 75]\n", "bar(X, H, width=0.1)\n", "xticks(X, ['Jeune', 'Adulte', 'Vieux'], rotation=-45)\n", "for i in range(len(X)) : text(X[i], H[i], str(H[i])+'%')\n", "title(\"Répartition\")\n", "show()" ] }, { "cell_type": "code", "execution_count": null, "id": "secret-concord", "metadata": {}, "outputs": [], "source": [ "figure(figsize=(5, 2))\n", "\n", "X=[1, 2, 10]\n", "H=[50, 20, 75]\n", "bar(X, H, width=0.1)\n", "xticks(X, ['Jeune', 'Adulte', 'Vieux'], rotation=-45)\n", "for i in range(len(X)) : text(X[i], H[i], str(H[i])+'%')\n", "title(\"Répartition\")\n", "show()" ] }, { "cell_type": "markdown", "id": "angry-female", "metadata": {}, "source": [ "

Le multiplot

\n", "

Il est possible de réaliser plusieurs graphique à l'aide de la fonction subplot qui prend en paramètre le nombre de ligne, le nombre de colonne et le numéro du graphique considéré.

" ] }, { "cell_type": "code", "execution_count": null, "id": "danish-charleston", "metadata": {}, "outputs": [], "source": [ "figure(figsize=(10, 2))\n", "\n", "subplot(121)\n", "X=[1, 2, 10]\n", "H=[50, 20, 75]\n", "bar(X, H, width=0.1)\n", "xticks(X, ['Jeune', 'Adulte', 'Vieux'], rotation=-45)\n", "for i in range(len(X)) : text(X[i], H[i], str(H[i])+'%')\n", "title(\"Répartition\")\n", "\n", "subplot(122)\n", "X=[1,2,3]\n", "Y=[-1,0,1]\n", "scatter(X, Y)\n", "\n", "show()" ] } ], "metadata": { "hide_input": false, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.0" } }, "nbformat": 4, "nbformat_minor": 5 }